The present invention relates generally to the field of database systems, especially database systems with a server to access the database. More specifically, the present invention is related to a method and a system for limiting the number of concurrent requests in a database system and therefore reducing lock occurrences in server/database systems.
In conventional client-server architectures, one or more nodes are connected to one or more servers via a network that allows for bi-directional communication between a client and a server. Typically, a server receives requests from multiple sources and handles them according to a defined processing scheme. Most commonly, a first-in first-out (FIFO) approach is used allowing for the first received request to be handled first by the server, the second request to be handled second, and so forth. In database systems incoming requests of the clients are handled using queues to organize the sequential arrangement of the requests.
The quality of service in a given client-server architecture is established based on the latency between a request being sent to a server and the time the requesting client receives a response from the server. The higher the load on a server, the more likely it is that the latency for receiving a response is increased. In many cases, the clients have built-in mechanisms that use “timeout” facilities to avoid waiting long periods of time for a request to be answered. In such cases, the request is aborted, and even if results are directed to the requesting client from the server, the requesting client ignores the results, or is unable to receive them as the connection has been terminated already by a client. In some applications, the client generates another request with the expectation that this request will be answered within the allotted time frame. This scheme may result in additional loading of the server's queue, thereby causing additional delays in the server's response time.
In large database environment with many clients connecting to the server to send requests to be processed and pushed to the database, database operations can become bottleneck and affect overall system performance. When the system performance is decreased, clients cannot connect to the server. Typically they are trying to get a connection later on, i.e. the number of server connections is increasing. It results in a downward spiral because the server has so many incoming connections that the database performance is decreased by resource-consuming lock handling. The poor database performance results in delays in request-processing which in turn increases the number of concurrent requests to be processed.
In addition, a request that waits to long on a server may be considered as failure, even though it was eventually processed by the server, because a time-out was triggered.
Therefore, it would be advantageous to have a mechanism for handling overload situations in a client-server environment. More specifically, it would be advantageous to have a mechanism that actively avoids time-out situations and allows the system to achieve maximum throughput.